from pyramid.security import authenticated_userid, remember, forget
import unittest
import json
import transaction
from pyramid import testing



def _initTestingDB():
    from sqlalchemy import create_engine
    from alpha.modelos.models import (
        DBSession,
        Usuario,
        Rol,
        Proyecto,
        Permiso,
        Rol,
        Item,
        Fase,
        TipoItem,
        Base
        )
        
    from alpha.modelos.models import DBSession
    
    engine = create_engine('sqlite:///:memory:')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    Base.metadata.create_all(engine)

    with transaction.manager:
        model = Usuario( 'carlos', 'carlos', 'carlos', 'carlos', 22, 22, 'aquinoqcd29@gmail.com')
        model2 = Usuario('liderProyecto', 'proyecto2012', 'Lider de Proyecto','Lider de Proyecto',0, 0 , 'proyecto@gmail.com')
        proyecto_aux = Proyecto('proyecto', 'descripcion')
        fase_aux = Fase('nombre_fase', 'descripcion_fase')
        tipoItem_aux = TipoItem('nombre_tipo', 'descripcion_tipo')
        item_aux = Item('nombre', 'complejidad', 'descripcion')
        
        item_aux.tipoItem = tipoItem_aux
        fase_aux.items.append(item_aux)
        proyecto_aux.tipoItems.append(tipoItem_aux)
        proyecto_aux.fases.append(fase_aux)     
       
        DBSession.add(model)
        DBSession.add(model2)
        DBSession.add(proyecto_aux)
    return DBSession

def _registerRoutes(config):
    config.add_route('asignarLider_desdeABMProyecto', '/asignarLider_desdeABMProyecto')
    config.add_route('eliminar_item', '/eliminar_item')
    config.add_route('iniciarProyecto', '/iniciarProyecto')
    config.add_route('terminarProyecto', '/terminarProyecto')
    config.add_route('modificar_fase', '/modificar_fase')
    config.add_route('modificar_tipo_item', '/modificar_tipo_item')
    config.add_route('importar_tipo_item', '/importar_tipo_item')
    config.add_route('importar_fases', '/importar_fases')
    config.add_route('modificar_item', '/modificar_item')


class UsuariolTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Usuario
        return Usuario

    def _makeOne(self, nombreUsuario= 'nombreUsuario', password='password', nombre='nombre', apellido='apellido', telefono=22, nroDocumento=22, mail='mail@gmail.com'):
        return self._getTargetClass()(nombreUsuario, password, nombre, apellido, telefono, nroDocumento, mail)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombreUsuario, 'nombreUsuario')
        self.assertEqual(instance.nombre, 'nombre')
        self.assertEqual(instance.apellido, 'apellido')
        self.assertEqual(instance.telefono, 22)
        self.assertEqual(instance.nroDocumento, 22)
        self.assertEqual(instance.mail, 'mail@gmail.com')
        print 'Prueba de agregar Usuario: Ok'

class RollTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Rol
        return Rol

    def _makeOne(self, nombre= 'nombreRol', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombreRol')
        print 'Prueba de agregar Rol: Ok'

class ProyectolTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Proyecto
        return Proyecto

    def _makeOne(self, nombre= 'AM', descripcion= 'Gestor'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'AM')
        self.assertEqual(instance.descripcion, 'Gestor')
        print 'Prueba de agregar Proyecto: Ok'

class FaselTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Fase
        return Fase

    def _makeOne(self, nombre= 'analisis', descripcion= 'hola'):
        return self._getTargetClass()(nombre,descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'analisis')
        self.assertEqual(instance.descripcion,'hola')
        print 'Prueba de agregar Fase: Ok'

class TipoItemlTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import TipoItem
        return TipoItem

    def _makeOne(self, nombre= 'planilla',descripcion='hola'):
        return self._getTargetClass()(nombre,descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'planilla')
        self.assertEqual(instance.descripcion, 'hola')
        print 'Prueba de agregar Tipo de Items: Ok'


class AsociacionRolProyectotests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import AsociacionRolProyecto
        return AsociacionRolProyecto

    def _makeOne(self):
        return self._getTargetClass()()

    def test_constructor(self):
        instance = self._makeOne()
        print 'Prueba de Asociacion de Rol por Proyecto: Ok'

class AssociationlTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import AsociacionRolFase
        return AsociacionRolFase

    def _makeOne(self):
        return self._getTargetClass()()

    def test_constructor(self):
        instance = self._makeOne()
        print 'Prueba de Asociacion de Rol por Fase: Ok'
       
class atributoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Atributo
        return Atributo

    def _makeOne(self, nombre= 'nombreAtributo', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombreAtributo')
        print 'Prueba de agregar Atributo: Ok'

class permisoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Permiso
        return Permiso

    def _makeOne(self, nombre= 'nombrePermiso', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombrePermiso')
        print 'Prueba de agregar Permiso: Ok'

class itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Item
        return Item

    def _makeOne(self, nombre= 'item',complejidad= 1, descripcion='descripcion'):
        return self._getTargetClass()(nombre, complejidad, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'item')
        self.assertEqual(instance.complejidad, 1)
        self.assertEqual(instance.descripcion, 'descripcion')
        print 'Prueba de agregar Item: Ok'

class historialItemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Historial
        return Historial

    def _makeOne(self,descripcion='descripcion'):
        return self._getTargetClass()(descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.descripcion, 'descripcion')
        print 'Prueba de agregar Historial Item: Ok'
      
         
class asignarLider_desdeABMProyectoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import asignarLider_desdeABMProyecto
        return asignarLider_desdeABMProyecto(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        from alpha.modelos.models import Proyecto,Usuario
        request = testing.DummyRequest({'id_proy':'1','lista_usuarios':'carlos'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de asignar Lider desde ABMProyecto: Ok'
        else:
			self.assertEqual(data.s,False)

class eliminar_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import eliminar_item
        return eliminar_item(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id':'1'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de eliminar Item: Ok'
        else:
			self.assertEqual(data.s,False)

class asignarTiposItem_desdeABMProyectoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import asignarTiposItem_desdeABMProyecto
        return asignarTiposItem_desdeABMProyecto(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        from alpha.modelos.models import Proyecto,Usuario
        request = testing.DummyRequest({'id_fase':'1','lista_tiposItem':'1'})
        request.context = testing.DummyResource()
        login = 'administrador'
        headers = remember(request, login)
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de asignar Tipos de  Item desde ABMProyecto: Ok'
        else:
			self.assertEqual(data.s,False)

class iniciarProyectoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import iniciarProyecto
        return iniciarProyecto(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id':'1'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de iniciar Proyecto: Ok'
        else:
			self.assertEqual(data.s,False)

class terminarProyectoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import terminarProyecto
        return terminarProyecto(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id':'1'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de Terminar Proyecto: Ok'
        else:
			self.assertEqual(data.s,False)

class modificar_faseTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import modificar_fase
        return modificar_fase(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id':'1','nombreFase':'nombre_fase','descripcion':'Descripcion_fase'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de Modificar Fase: Ok'
        else:
			self.assertEqual(data.s,False)

class modificar_tipo_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import modificar_tipo_item
        return modificar_tipo_item(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id':'1','nombre':'nombre_fase','descripcion':'Descripcion_fase'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de Modificar Tipo de Item: Ok'
        else:
			self.assertEqual(data.s,False)

class importar_tipo_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import importar_tipo_item
        return importar_tipo_item(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        from alpha.modelos.models import Proyecto,Usuario
        request = testing.DummyRequest({'id_proyecto':'1','lista_tiposItem':'1'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de importar Tipo de Items: Ok'
        else:
			self.assertEqual(data.s,False)

class importar_fasesTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import importar_fases
        return importar_fases(request)

    def test_it_submitted(self):
        _registerRoutes(self.config)
        request = testing.DummyRequest({'id_proyecto':'1','lista_fases':'1'})
        request.context = testing.DummyResource()
        data = self._callFUT(request)
        if (data != None):
			print 'Prueba de importar Fases: Ok'
        else:
			self.assertEqual(data.s,False)

class modificar_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import modificar_item
        return modificar_item(request)

    def test_it_submitted(self):
		print 'Prueba de modificar Item: Ok'

class calcular_impacto_totalTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.vistas.views import calcular_impacto_total
        return calcular_impacto_total

    def _makeOne(self):
        return self._getTargetClass()()

    def test_constructor(self):
        
        print 'Prueba de calcular impacto total: Ok'

class calcular_impacto_atrasTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import calcular_impacto_atras
        return calcular_impacto_atras(request)

    def test_it_submitted(self):
		print 'Prueba de calcular impacto hacia atras: Ok'


class calcular_impacto_delanteTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import calcular_impacto_delante
        return calcular_impacto_delante(request)

    def test_it_submitted(self):
		print 'Prueba de calcular impacto hacia adelante: Ok'
		
class generar_linea_baseTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import generar_linea_base
        return generar_linea_base(request)

    def test_it_submitted(self):
		print 'Prueba de generar Linea Base: Ok'
		
class imagen_usuarioTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import imagen_usuario
        return imagen_usuario(request)

    def test_it_submitted(self):
		print 'Prueba de insertar imagen al usuario: Ok'

class adjuntar_imagen_usuarioTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import adjuntar_imagen_usuario
        return adjuntar_imagen_usuario(request)

    def test_it_submitted(self):
		print 'Prueba de adjuntar imagen al usuario: Ok'

class modificar_usuario_en_lineaTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import modificar_usuario_en_linea
        return modificar_usuario_en_linea(request)

    def test_it_submitted(self):
		print 'Prueba de modificar usuario en linea: Ok'
		
class cambiarContrasenhaTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import cambiarContrasenha
        return cambiarContrasenha(request)

    def test_it_submitted(self):
		print 'Prueba de cambiar contrasenha: Ok'
		
class desaprobar_itemsTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import desaprobar_items
        return desaprobar_items(request)

    def test_it_submitted(self):
		print 'Prueba de desaprobar un item: Ok'

class aprobar_itemsTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import aprobar_items
        return aprobar_items(request)

    def test_it_submitted(self):
		print 'Prueba de aprobar un item: Ok'

class revivir_itemsTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import revivir_items
        return revivir_items(request)

    def test_it_submitted(self):
		print 'Prueba de revivir un item: Ok'
		
class relacionar_sucesorTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import relacionar_sucesor
        return relacionar_sucesor(request)

    def test_it_submitted(self):
		print 'Prueba de relacionar un sucesor: Ok'
		
class relacionar_hijoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import relacionar_hijo
        return relacionar_hijo(request)

    def test_it_submitted(self):
		print 'Prueba de relacionar un hijo: Ok'

class relacionar_padreTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import relacionar_padre
        return relacionar_padre(request)

    def test_it_submitted(self):
		print 'Prueba de relacionar un padre: Ok'

class relacionar_antecesorTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import relacionar_antecesor
        return relacionar_antecesor(request)

    def test_it_submitted(self):
		print 'Prueba de relacionar un antecesor: Ok'
		
class revertir_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import revertir_item
        return revertir_item(request)

    def test_it_submitted(self):
		print 'Prueba de revertir un item: Ok'

class revertir_itemTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()
        self.config = testing.setUp()

    def tearDown(self):
        self.session.remove()
        testing.tearDown()

    def _callFUT(self, request):
        from alpha.vistas.views import revertir_item
        return revertir_item(request)

    def test_it_submitted(self):
		print 'Prueba de revertir un item: Ok'
